`:top
`!Visual Basic .NET`! (Abk. `*VB.NET`*) ist eine `F33f`_`[Programmiersprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f von `F33f`_`[Microsoft`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft]`_`f, die auf dem `F33f`_`[.NET Framework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.Net-Framework]`_`f aufbaut. Sie wurde `F33f`_`[2002`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=2002]`_`f publiziert und ist keine einfache Weiterentwicklung des Vorgängers `F33f`_`[Visual Basic`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Basic_Classic]`_`f 6, sondern wurde in weiten Teilen neu konzipiert. Die Sprache wird allerdings von Microsoft seit Version 8 offiziell wieder nur als `!Visual Basic`! bezeichnet.
Visual Basic .NET produziert einen `F33f`_`[Zwischencode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zwischencode]`_`f für eine von Microsoft entwickelte `F33f`_`[virtuelle Maschine`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Virtuelle_Maschine]`_`f, die `F33f`_`[Common Language Runtime`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Common_Language_Runtime]`_`f (CLR). Diese Maschine ist im `F33f`_`[.NET Framework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.Net-Framework]`_`f enthalten.
Der Zwischencode wird erst zur Laufzeit in Maschinencode übersetzt, durch diese Zwischenstufe der virtuellen Maschine bleibt sie mit anderen .NET-Sprachen interoperabel, zur Ausführung wird jedoch das .NET Framework benötigt.
Visual Basic .NET unterstützt die `F33f`_`[objektorientierte Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f vollständig und verfügt über eine `F33f`_`[Ausnahmebehandlung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ausnahmebehandlung]`_`f, wie sie auch aus anderen Programmiersprachen wie `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f oder `F33f`_`[C++`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C++]`_`f bekannt ist.
>>Contents
• `F0af`_`[Geschichte`#geschichte]`_`f
• `F0af`_`[2002–2005: Visual Basic .NET`#2002-2005-visual-basic-net]`_`f
• `F0af`_`[2005–2007: Visual Basic 8 und 9`#2005-2007-visual-basic-8-und-9]`_`f
• `F0af`_`[2010–2019: Visual Basic 10 bis 16`#2010-2019-visual-basic-10-bis-16]`_`f
• `F0af`_`[Eigenschaften`#eigenschaften]`_`f
• `F0af`_`[Windows-Anwendungen`#windows-anwendungen]`_`f
• `F0af`_`[Web-Anwendungen`#web-anwendungen]`_`f
• `F0af`_`[Besonderheiten gegenüber anderen .NET-Sprachen`#besonderheiten-gegen-ber-anderen-net-sprachen]`_`f
• `F0af`_`[Unterschiede zu Visual Basic Classic`#unterschiede-zu-visual-basic-classic]`_`f
• `F0af`_`[Beispiel`#beispiel]`_`f
• `F0af`_`[Hallo-Welt-Beispiel`#hallo-welt-beispiel]`_`f
• `F0af`_`[Einfache MessageBox`#einfache-messagebox]`_`f
• `F0af`_`[FileStream-Beispiel`#filestream-beispiel]`_`f
• `F0af`_`[Networking-Beispiel`#networking-beispiel]`_`f
• `F0af`_`[Entwicklungsumgebungen`#entwicklungsumgebungen]`_`f
• `F0af`_`[Rechtliche Aspekte`#rechtliche-aspekte]`_`f
• `F0af`_`[Siehe auch`#siehe-auch]`_`f
• `F0af`_`[Literatur`#literatur]`_`f
• `F0af`_`[Weblinks`#weblinks]`_`f
• `F0af`_`[Einzelnachweise`#einzelnachweise]`_`f
-─
>>Geschichte
Um die Jahrtausendwende hatte Visual Basic seinen ursprünglichen Vorteil gegenüber anderen Programmiersprachen, einfach eine graphische Oberfläche zu erstellen, eingebüßt. Viele andere Hochsprachen boten nun ebenfalls die Möglichkeiten, einfach Windows-Benutzeroberflächen zu erstellen, zum Beispiel C++ mit den `F33f`_`[Microsoft Foundation Classes`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Foundation_Classes]`_`f (MFC). Darüber hinaus hatte sich Visual Basic inzwischen zu einem komplexen und eher inhomogenen Produkt entwickelt, dessen Wartung und Verbesserung zunehmend schwieriger wurde. Wohl aus diesen Gründen stoppte Microsoft die Weiterentwicklung dieses Produktes (trotz des kommerziellen Erfolgs und des Protestes vieler VB-Programmierer) und integrierte die Programmiersprache Visual Basic in die hauseigene `F33f`_`[.Net-Framework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.Net-Framework]`_`f-Architektur. Dabei wurde die Sprache zu einem hohen Grad verändert, um den Ansprüchen an eine .NET-Sprache zu genügen. Hierdurch wurde die vollständige `F33f`_`[Objektorientierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f sowie die Übersetzung in die `F33f`_`[Common Intermediate Language`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Common_Intermediate_Language]`_`f ermöglicht.
>>>2002–2005: Visual Basic .NET
Mit Visual Studio .NET erschien 2002 erstmals eine Visual Studio Version, die auf dem `F33f`_`[.Net-Framework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.Net-Framework]`_`f aufbaute und somit Visual Basic .NET unterstützte. Durch das Propagieren der zu diesem Zeitpunkt noch recht jungen .NET-Technologie und die Namensbezeichnung „Visual Studio .NET“ wurde bei den Kunden jedoch der Eindruck erweckt, es handle sich um ein Produkt ausschließlich für diese Plattform. Dies hatte zur Folge, dass viele Entwickler und Unternehmen zurückhaltend weiterhin Visual Studio mit dem klassischen Visual Basic verwendeten.
Das erste Update auf Visual Basic 7.1 bzw. .NET-Framework 1.1 (build 4322) sowie „Visual Studio .NET 2003“ brachte nur kleinere Änderungen, was sich im „kleinen“ Versionssprung widerspiegelt. Etwa kann ab Visual Basic 7.1 eine Zählervariable im Kopf einer `*For`*-Schleife deklariert werden. Außerdem wurde die Unterstützung für mobile Geräte hinzugefügt. Auf diesen dient nicht das .NET-Framework 1.1 als `F33f`_`[Laufzeitumgebung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Laufzeitumgebung]`_`f, sondern das „`F33f`_`[.NET Compact Framework`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.NET_Compact_Framework]`_`f 1.0“.
>>>2005–2007: Visual Basic 8 und 9
Im November 2005 erfolgte der erste große Versionssprung des .NET-Frameworks und des .NET-Compact-Frameworks auf Version 2.0, begleitet von der Veröffentlichung des neuen Visual Basic 8 als Teil von „Visual Studio 2005“ (das „.NET“ ist aus dem Namen entfallen). Mit dieser Version wurden einige Restrukturierungen an der .NET-Laufzeitbibliothek vorgenommen. Am auffälligsten ist die Unterstützung der `F33f`_`[generischen Programmierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Generische_Programmierung]`_`f, die den aus C++ bekannten `F33f`_`[Templates`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Template_(C++)]`_`f ähnelt. Viele Schnittstellen und Attribute der `F33f`_`[Laufzeitbibliothek`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Laufzeitbibliothek]`_`f sind auch als generische Implementation verfügbar. Weiter ist ab der Version 2005 eine kostenlose, im Leistungsumfang eingeschränkte `*Express Edition`* von Visual Basic .NET verfügbar.`:cite-ref-3[`F5bf`_`[3`#cite-note-3]`_`f]
Mit Visual Basic 8 wurde der Operator `*IsNot`* eingeführt, der Aufsehen erlangte, da diese Erfindung zum Patent anmeldet wurde.`:cite-ref-us20040230959-4-0[`F5bf`_`[4`#cite-note-us20040230959-4]`_`f] Eine andere Neuerung ist der `*My`*-Namensraum, der unterschiedliche systemabhängige Funktionen in einer für den Programmierer übersichtlichen Weise darstellt, etwa den Zugriff auf Computerkomponenten, die `F33f`_`[Windows-Registrierungsdatenbank`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Registrierungsdatenbank]`_`f oder Informationen über das Betriebssystem und den aktuellen Benutzer.
2007 wurde parallel zur Veröffentlichung von `F33f`_`[Windows Vista`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Windows_Vista]`_`f die neue Visual Basic-Version 9`:cite-ref-5[`F5bf`_`[5`#cite-note-5]`_`f] bzw. das „Visual Studio 2008“ veröffentlicht. Die größte sprachliche Änderung ist wohl die Unterstützung der neuen .NET-Komponente `F33f`_`[LINQ`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=LINQ]`_`f. Visual Basic 9 basiert auf dem mit Windows Vista ausgelieferten und für `F33f`_`[Windows XP`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Windows_XP]`_`f erhältlichen `F33f`_`[.NET Framework 3.0`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.Net-Framework]`_`f (vormals `*WinFX`*). Der wohl bedeutendste Bestandteil des Versionsupdates ist die `F33f`_`[Windows Presentation Foundation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Windows_Presentation_Foundation]`_`f, die nicht nur `F33f`_`[Windows Forms`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Windows_Forms]`_`f, sondern auch das Windows-interne Grafiksubsystem `F33f`_`[GDI`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Graphics_Device_Interface]`_`f ablöst.`:cite-ref-6[`F5bf`_`[6`#cite-note-6]`_`f]
Seit November 2007 basieren alle Visual Studio 2008-Versionen auf dem .NET Framework 3.5, mit dem die folgenden Technologien eingeführt bzw. erweitert wurden: `*Language Integrated Query`* (LINQ), neue `F33f`_`[Compiler`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Compiler]`_`f für C#, Visual Basic und C++, ASP.NET mit AJAX, `F33f`_`[ADO.NET`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ADO.NET]`_`f Entity Framework, Datenanbieterunterstützung für SQL Server 2008, Unterstützung für `*.NET Framework Client Profile`* u. a.`:cite-ref-7[`F5bf`_`[7`#cite-note-7]`_`f]
>>>2010–2019: Visual Basic 10 bis 16
Visual Basic 10 wurde 2010 zusammen mit `F33f`_`[Visual Studio 2010`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f veröffentlicht und brachte kleinere Änderungen mit sich. Dazu zählen automatisch implementierte Eigenschaften, Sammlungsinitialisierer, implizite Zeilenfortsetzung, dynamisch generische Co/Contra-Varianzen und ein globaler Namespace-Zugriff.
Im Jahr 2012 wurden Visual Basic 11 und `F33f`_`[Visual Studio 2012`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f veröffentlicht. Dabei führte die neue Version die `F33f`_`[Schlüsselwörter`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Schlüsselwort_(Programmierung)]`_`f async und await, Iteratoren und "caller info"-Attribute ein.
Der Release von `F33f`_`[Visual Studio 2013`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f im Jahr 2013 brachte auch die Version 12 von Visual Basic mit sich. Wichtigste Neuerung war hier die Technologievorschau auf die .NET-Compiler-Plattform ("Roslyn").
Visual Basic 13 und 14 wurden im Jahr 2015 mit `F33f`_`[Visual Studio 2015`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f veröffentlicht.`:cite-ref-0-8-0[`F5bf`_`[8`#cite-note-0-8]`_`f] Die Version 14 erweiterte die Visual Basic `F33f`_`[Programmiersprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f um den Operator `*?.`*, den `*NameOf`* Operator, String-Interpolation und Multiline-Strings.`:cite-ref-9[`F5bf`_`[9`#cite-note-9]`_`f]
2017 wurde durch den Release von `F33f`_`[Visual Studio 2017`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f auch Visual Basic 15 eingeführt. Neue Features in dieser Version sind die Einführung von Tupels und der erweiterte Support für `F33f`_`[C#`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=C-Sharp]`_`f-Return-Werte.
Die aktuellste Version von Visual Studio, `F33f`_`[Visual Studio 2019`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f, wurde 2019 gemeinsam mit Visual Basic 16 veröffentlicht. Fokussiert wurde sich dabei auf mehr Funktionen der Visual Basic Runtime (microsoft.visualbasic.dll) für `F33f`_`[.NET Core`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.NET_(Plattform)]`_`f. Außerdem ist Visual Basic 16 die erste Version von Visual Basic, die auf den .NET Core ausgerichtet ist.`:cite-ref-1-10-0[`F5bf`_`[10`#cite-note-1-10]`_`f]
>>Eigenschaften
>>>Windows-Anwendungen
Für die Entwicklung von Windows-Anwendungen wird `F33f`_`[Windows Forms`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Windows_Forms]`_`f benutzt. Hierbei handelt es sich um ein `F33f`_`[ereignisorientiertes Programmiermodell`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ereignis_(Programmierung)]`_`f, bei dem entsprechende Ereignis-`F33f`_`[Prozeduren`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Prozedur_(Programmierung)]`_`f aufgerufen werden, wenn das `F33f`_`[Betriebssystem`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Betriebssystem]`_`f eine bestimmte Benutzeraktion, wie z. B. das Betätigen einer Schaltfläche, meldet.
Im Gegensatz zu `F33f`_`[Visual Basic`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Basic_Classic]`_`f 6 werden Windows Forms nicht in einem speziellen Format gespeichert, sondern wie normale Klassen erstellt und benutzt, die von einer entsprechenden Basisklasse (meist `*System.Windows.Forms.Form`*) abgeleitet werden.
Bei der `F33f`_`[Instanziierung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objekt_(Programmierung)]`_`f einer solchen Klasse werden im `F33f`_`[Konstruktor`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Konstruktoren_und_Destruktoren]`_`f die Objekte erzeugt, die innerhalb des Fensters dargestellt werden sollen. Dieses Modell wird auch in der `F33f`_`[Programmiersprache`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Programmiersprache]`_`f `F33f`_`[Java`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Java_(Programmiersprache)]`_`f benutzt.
Moderne `F33f`_`[Entwicklungsumgebungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Integrierte_Entwicklungsumgebung]`_`f ermöglichen die visuelle Erstellung von Formularen, wobei der für den Konstruktor notwendige Code von der Entwicklungsumgebung erzeugt wird.
>>>Web-Anwendungen
Für die Entwicklung von Web-Anwendungen wird `F33f`_`[ASP.NET`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ASP.NET]`_`f benutzt. Hierbei erfolgt eine Trennung zwischen der Darstellung der Webseite und dem auszuführenden Code, der sich in einer `*VB.NET`*-Klasse befindet. Dies hat den Vorteil, dass der von `F33f`_`[ASP`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Active_Server_Pages]`_`f bekannte `F33f`_`[Spaghetticode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Spaghetticode]`_`f, der gerade die Wartung größerer Projekte erschwert, vermieden wird.
Für die Ausführung von ASP.NET-Anwendungen wird der `F33f`_`[IIS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Internet_Information_Services]`_`f von `F33f`_`[Microsoft`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft]`_`f oder der `F33f`_`[Apache HTTP Server`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Apache_HTTP_Server]`_`f mit dem `F33f`_`[mod_mono`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mono_(Software)]`_`f-Modul benötigt.
ASP.NET ermöglicht auch die Entwicklung von `F33f`_`[Webservices`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Webservice]`_`f. Die für die Publizierung von Webservices benötigten Informationen werden von der `F33f`_`[Entwicklungsumgebung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Integrierte_Entwicklungsumgebung]`_`f auf Basis von Attributen, die der Programmierer in das Programm einfügt, generiert.
Für den Zugriff auf einen Webservice kann von der Entwicklungsumgebung auf Anforderung eine Klasse generiert werden, die den Zugriff auf die `F33f`_`[Methoden`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Methode_(Programmierung)]`_`f des Webservices kapseln.
>>>Besonderheiten gegenüber anderen .NET-Sprachen
Als .NET-Sprache unterliegt Visual Basic .NET den Vor- und Nachteilen dieser Plattform. Visual Basic Classic machte viele kleinere Dinge anders als andere Sprachen. Aus Gründen der Abwärtskompatibilität sind viele dieser Punkte als „Altlasten“ in Visual Basic .NET enthalten. Einige Beispiele:
• Üblicherweise entspricht der in eine Zahl konvertierte logische Wert `*Falsch`* bzw. `*False`* dem Wert 0, `*Wahr`* oder `*True`* wird als 1 interpretiert. Visual Basic Classic verwendet für `*True`* jedoch den Wert −1 (alle Bits auf 1). Diese Konvention erlaubte es, nicht zwischen einem logischen und einem binären `*Not`*-Operator unterscheiden zu müssen. Daher ergibt auch in Visual Basic .NET die Konvertierungen `B100`F9d9CInt(True)`f`b oder `B100`F9d9CType(True, Int32)`f`b noch immer den Wert −1, auch wenn VB.NET inzwischen intern auch mit 0 und 1 arbeitet. Der Aufruf der .NET Framework-Methode `B100`F9d9Convert.ToInt32(True)`f`b evaluiert hingegen auf 1. Die .NET Runtime schaut übrigens 0 als `*False`* an, alles andere als `*True`*.
• In den meisten Programmiersprachen ist die Größe in einer Arraydeklaration die Anzahl Einträge, also z. B. `B100`F9d9int a[5];`f`b deklariert ein Array mit 5 Elementen (in .NET standardmäßig Index 0 bis 4). In VB.NET deklariert `B100`F9d9Dim a(5) As Integer`f`b ein Array mit höchstem Index 5, somit also ein Array mit 6 Elementen (Index 0 bis 5), um abwärtskompatibel zur VB Classic Syntax `B100`F9d9Dim a([lowerBound To] upperBound)`f`b zu bleiben.
• Sprachunterstützung für XML, z. B. für Literals oder für das Abfragen und Erstellen von neuen Elementen
• VB.NET ist tolerant bei der Initialisierung von Feldern, sie dürfen Referenzen auf die eigenen Instanz oder andere Felder benutzen
• VB.NET unterstützt Inner-Interfaces und Inner-Klassen in Interfaces. Dieses Verfahren erlaubt es, weitere Versionen eines Interfaces zu erstellen. Der Konsument des Interfaces erhält durch IntelliSense beim Implementieren der ursprünglichen Version den visuellen Hinweis, dass hier noch weitere Versionen vorhanden sind und kann die entsprechende auswählen.
• VB.NET braucht keine Unterscheidung zwischen out- und byRef-Parametern
• VB.NET erlaubt das Überschreiben der Iterationsvariable
• VB.NET erlaubt das Verwenden von byRef in ExtensionMethods, was es erlaubt, die Originalinstanz zu initialisieren oder zu ersetzen.
• VB.NET hat mehr Linq-Schlüsselwörter als andere Sprachen, so kann z. B. das Schlüsselwort Distinct verwendet werden anstelle des Aufrufs der gleichnamigen Extensionmethod, und falls der Output vom gleichen Typ ist wie der Input, so kann das Select weggelassen werden. Dies macht Linq-Ausdrücke in der Regel kürzer und somit besser lesbar.
>>>Unterschiede zu Visual Basic Classic
Siehe auch
:
Visual Basic Classic
Bis auf die Sprachsyntax ist Visual Basic .NET nicht mit den vorherigen Visual-Basic-Versionen vergleichbar. Als vollwertige .NET-Sprache ist VB.NET vollständig `F33f`_`[objektorientiert`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Objektorientierte_Programmierung]`_`f und der Quellcode wird in die `F33f`_`[Common Intermediate Language`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Common_Intermediate_Language]`_`f übersetzt, nicht in nativen Win32-Code. Dieser Code wird zur Laufzeit in `F33f`_`[Maschinencode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Maschinensprache]`_`f umgesetzt und kann hierdurch an die aktuelle Plattform angepasst werden.
Die Umstellung auf die .NET-Technologie brachte neben diesen Änderungen im Hintergrund auch Änderungen für den Programmierer. Das .NET-Framework stellt zahlreiche Funktionsbibliotheken zur Verfügung, z. B. für Dateizugriffe oder zum Lesen und Schreiben von `F33f`_`[XML`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Extensible_Markup_Language]`_`f-Dateien. Am wichtigsten waren zum Zeitpunkt der Einführung von VB.NET die `*`F33f`_`[Windows Forms`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Windows_Forms]`_`f`*, die das veraltete `*Thunder-Forms`*-System der vorherigen Versionen zur Erstellung von Benutzeroberflächen ablöst. Der augenscheinlichste Unterschied der `*Windows Forms`* gegenüber den `*Thunder Forms`* ist die Tatsache, dass kein spezielles `F33f`_`[Dateiformat`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Dateiformat]`_`f mehr zur Speicherung verwendet wird, sondern die Formulare als Klassen durch Code erstellt werden. Dabei wird der `F33f`_`[Konstruktor`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Konstruktoren_und_Destruktoren]`_`f der Fensterklasse verwendet, um die ebenfalls durch Klassen repräsentierten Steuerelemente zu erstellen. Moderne `F33f`_`[Integrierte Entwicklungsumgebungen`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Integrierte_Entwicklungsumgebung]`_`f ermöglichen die visuelle Erstellung von Formularen, wobei der für den Konstruktor der Fensterklasse notwendige Code von der Entwicklungsumgebung erzeugt wird. Des Weiteren lassen sich mit Visual Basic .NET im Gegensatz zu Visual Basic 6 auch Web-Anwendungen erstellen. Mit Einführung des .NET-Frameworks wurde `*Web Forms`*, eine GUI-Bibliothek für die `F33f`_`[ASP.NET`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=ASP.NET]`_`f-Umgebung, zur Verfügung gestellt.
Neben diesen Vorteilen bringt die Umstellung allerdings auch einige Probleme mit sich. Da VB.NET nicht die Visual Basic 6-Funktionsbibliothek, sondern das .NET-Framework verwendet, kann ein Visual-Basic-Classic-Codeprojekt nur mit großem Aufwand auf die neue Version migriert werden. Microsoft lieferte zwar mit seiner Entwicklungsumgebung `F33f`_`[Visual Studio`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f bis zur Version 2008 einen sogenannten Migrationsassistenten mit. Dieser wandelt die Codestruktur meist korrekt um und beherrscht bis auf wenige Spezialfälle die Konvertierung von `*Thunder Forms`* nach `*Windows Forms`*, hat aber zum Beispiel starke Probleme mit Grafikprogrammierung, da die verwendeten Grafiksysteme von Visual Basic Classic (`F33f`_`[GDI`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Graphics_Device_Interface]`_`f, in `*Thunder-Forms`*-Steuerelementen gekapselt) und Visual Basic .NET (`F33f`_`[GDI+`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=GDI+]`_`f) praktisch inkompatibel zueinander sind. Zur besseren Portierung gibt es von Microsoft neben dem Migrationsassistenten eine Funktionssammlung im .NET-Framework (im `*Microsoft.VisualBasic`*-`F33f`_`[Namensraum`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Namensraum]`_`f), die einige wichtige Visual-Basic-Classic-Funktionen unter .NET zur Verfügung stellt. Bestehende `F33f`_`[COM`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Component_Object_Model]`_`f-Komponenten können ohne Einschränkungen weiterbenutzt werden. Neben dem Problem der Inkompatibilität bedeutete der Verlust der „Edit and Continue“-Funktion in Visual Studio .NET einen großen entwicklungstechnischen Rückschritt, so konnte man im Gegensatz zu Visual Basic 6 den Code im Debug Modus nicht mehr ändern und die Ausführung ohne Unterbrechung weiterlaufen lassen. Diese Funktion wurde mit Visual Basic 2005 jedoch wieder eingeführt.
In Visual Basic .NET kann man, anders als in Visual Basic Classic, auch dann Programme erstellen, wenn man keine Entwicklungsumgebung erworben hat. Der Namensraum `B100`F9d9System.Reflection.Emit`f`b stellt Funktionen bereit, um von einer eigenen Anwendung heraus kompilieren zu können, zudem gibt es einen Kommandozeilencompiler namens `*vbc.exe`*.
>>Beispiel
>>>Hallo-Welt-Beispiel
Der folgende `*`F33f`_`[Quelltext`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Quelltext]`_`f`* stellt ein einfaches Visual-Basic-`F33f`_`[Programm`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Computerprogramm]`_`f dar, das die Meldung „Hallo Welt!“ auf der `F33f`_`[Standardausgabe`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Standard-Datenströme]`_`f ausgibt, welche in der Regel ein `F33f`_`[Befehlsfenster`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Kommandozeile]`_`f (Konsole) ist.
`B100`F9d9Public Class Program`f`b
`B100`F9d9 Public Shared Sub Main()`f`b
`B100`F9d9 Console.WriteLine("Hallo Welt!")`f`b
`B100`F9d9 End Sub`f`b
`B100`F9d9End Class`f`b
`!Erläuterungen:`!
Bei diesem Programm handelt es sich um eine einfache `F33f`_`[Konsolenanwendung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Konsolenanwendung]`_`f, die aus einer einzigen Klasse besteht. In diesem Fall enthält die Klasse nur die statische `B100`F9d9Main()`f`b-`F33f`_`[Methode`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Methode_(Programmierung)]`_`f – in der VB-Nomenklatur ein `B100`F9d9shared sub`f`b –, die für gewöhnlich beim Start in jeder Anwendung einmal als erstes aufgerufen wird.
Die Ausgabeanweisung `B100`F9d9Console.WriteLine`f`b stammt aus der `F33f`_`[.NET-Klassenbibliothek`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.Net-Framework]`_`f und ermöglicht die Ausgabe auf der Standardausgabe, wobei die Ausgabe mit einem `F33f`_`[Zeilenumbruch`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Zeilenumbruch]`_`f abgeschlossen wird.
>>>Einfache MessageBox
`B100`F9d9Imports System.Windows.Forms`f`b
`B100`F9d9`f`b
`B100`F9d9Private Class Program`f`b
`B100`F9d9 Public Shared Sub Main()`f`b
`B100`F9d9 MessageBox.Show("Text", "Titel", MessageBoxButtons.OK, MessageBoxIcon.Hand)`f`b
`B100`F9d9 End Sub`f`b
`B100`F9d9End Class`f`b
>>>FileStream-Beispiel
`B100`F9d9Imports System.IO`f`b
`B100`F9d9Imports System.Text`f`b
`B100`F9d9`f`b
`B100`F9d9Private Class Program`f`b
`B100`F9d9 Public Shared Sub Main()`f`b
`B100`F9d9 ' Text, der in die Datei geschrieben wird`f`b
`B100`F9d9 Const textToWrite As String = "Hallo Welt"`f`b
`B100`F9d9 Const fileName As String = "dateiname.txt"`f`b
`B100`F9d9`f`b
`B100`F9d9 ' Datei "dateiname.txt" wird erstellt oder überschrieben`f`b
`B100`F9d9 Using stream As New FileStream(fileName, FileMode.Create, FileAccess.Write)`f`b
`B100`F9d9 ' Der Text wird UTF8-kodiert in die Datei geschrieben`f`b
`B100`F9d9 Dim data As Byte() = Encoding.UTF8.GetBytes(textToWrite)`f`b
`B100`F9d9 stream.Write(data, 0, data.Length)`f`b
`B100`F9d9 End Using 'Datei wird geschlossen.`f`b
`B100`F9d9 End Sub`f`b
`B100`F9d9End Class`f`b
>>>Networking-Beispiel
Basierend auf Visual Basic 14 mit String-Interpolation (Visual Studio 2015):
`B100`F9d9Imports System.Console`f`b
`B100`F9d9Imports System.Text`f`b
`B100`F9d9Imports System.Net`f`b
`B100`F9d9Imports System.Net.Sockets`f`b
`B100`F9d9`f`b
`B100`F9d9''' <summary>`f`b
`B100`F9d9''' Beispielprogramm: Socketverbindung`f`b
`B100`F9d9''' </summary>`f`b
`B100`F9d9''' <remarks>Für weitere Details siehe <see cref="System.Net.Sockets.Socket"/>.</remarks>`f`b
`B100`F9d9Class Program`f`b
`B100`F9d9 ''' <summary>`f`b
`B100`F9d9 ''' Einstiegspunkt`f`b
`B100`F9d9 ''' </summary>`f`b
`B100`F9d9 Public Shared Sub Main()`f`b
`B100`F9d9 ' Daten, die gesendet werden`f`b
`B100`F9d9 Const textToSend As String = "Hallo Welt"`f`b
`B100`F9d9 ' Endpunkt, zu dem verbunden wird`f`b
`B100`F9d9 Const localhost As String = "127.0.0.1"`f`b
`B100`F9d9 Const port As Integer = 80`f`b
`B100`F9d9`f`b
`B100`F9d9 Dim data As Byte() = Encoding.UTF8.GetBytes(textToSend)`f`b
`B100`F9d9 Dim ip As IPAddress = IPAddress.Parse(localhost)`f`b
`B100`F9d9 Dim ipEndPoint As New IPEndPoint(ip, port)`f`b
`B100`F9d9`f`b
`B100`F9d9 ' Socket, das verwendet wird`f`b
`B100`F9d9 Using socket As New Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp)`f`b
`B100`F9d9 socket.Connect(ipEndPoint)`f`b
`B100`F9d9 ' Es wird zum Endpunkt verbunden`f`b
`B100`F9d9 Dim byteCount As Integer = socket.Send(data, SocketFlags.None)`f`b
`B100`F9d9 ' Daten werden gesendet`f`b
`B100`F9d9 WriteLine($"Es wurden {byteCount} Bytes gesendet")`f`b
`B100`F9d9 Dim buffer As Byte() = New Byte(255) {}`f`b
`B100`F9d9 ' Puffer für die zu empfangenen Daten`f`b
`B100`F9d9 byteCount = socket.Receive(buffer, SocketFlags.None)`f`b
`B100`F9d9 ' Daten werden empfangen`f`b
`B100`F9d9 ' Wenn eine Antwort erhalten wurde, diese ausgeben`f`b
`B100`F9d9 If byteCount > 0 Then`f`b
`B100`F9d9 WriteLine($"Es wurden {byteCount} Bytes empfangen")`f`b
`B100`F9d9 Dim answer As String = Encoding.UTF8.GetString(buffer)`f`b
`B100`F9d9 WriteLine($"Empfangene Daten: {answer}")`f`b
`B100`F9d9 End If`f`b
`B100`F9d9 End Using ' Verbindung wird geschlossen.`f`b
`B100`F9d9 End Sub`f`b
`B100`F9d9End Class`f`b
>>Entwicklungsumgebungen
Die am häufigsten eingesetzte `F33f`_`[IDE`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Integrierte_Entwicklungsumgebung]`_`f ist `F33f`_`[Visual Studio`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f, das Visual Basic vollumfänglich unterstützt. `F33f`_`[SharpDevelop`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SharpDevelop]`_`f bis zur Version 4 (kurz: `*#develop`*) und mit deutlichen Abstrichen auch `F33f`_`[MonoDevelop`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MonoDevelop]`_`f, die Entwicklungsumgebung des `F33f`_`[Mono-Projektes`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mono_(Software)]`_`f, können ebenfalls verwendet werden.
Mit dem in .NET enthaltenen Kommandozeilentool `*vbc.exe`* können Visual-Basic-Dateien, mit `*msbuild.exe`* Visual-Basic-Projekte kompiliert werden.
>>Rechtliche Aspekte
`F33f`_`[Visual Basic Classic`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Basic_Classic]`_`f ist, anders als viele moderne Hochsprachen, kein `F33f`_`[offener Standard`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Offener_Standard]`_`f, sondern `F33f`_`[proprietär`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Proprietär]`_`f und geistiges Eigentum von `F33f`_`[Microsoft`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft]`_`f. Mit Visual Basic .NET hat sich diese Bindung gelockert, da einige Teile der .NET-Infrastruktur durch die `F33f`_`[Ecma International`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Ecma_International]`_`f standardisiert worden sind. Die Patentierung des in Visual Basic .NET 8 eingeführten `*IsNot`*-Operators war jedoch wieder ein Schritt in Richtung einer geschlossenen Umgebung.
Microsoft ist inzwischen an der Patentierung gescheitert.`:cite-ref-us20040230959-4-1[`F5bf`_`[4`#cite-note-us20040230959-4]`_`f] Auch hat Microsoft inzwischen – beginnend mit Roslyn und der 2014 gegründeten `F33f`_`[.NET Foundation`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=.NET_(Oberbegriff)]`_`f – eine Open-Source-Strategie. Die Roslyn-Compiler-Umgebung (inkl. Compiler, Syntax Tree Analyzer, IL-Emitter u.v.m.) für VB.NET ist auch komplett in VB.NET geschrieben und Open Source (Apache 2.0 lizenziert).
>>Siehe auch
• `F33f`_`[Visual Studio`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Visual_Studio]`_`f
• `F33f`_`[Mono-Projekt`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Mono_(Software)]`_`f mit .NET weitgehend kompatibles Framework, für `F33f`_`[Windows`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Microsoft_Windows]`_`f, `F33f`_`[macOS`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MacOS]`_`f und `F33f`_`[Linux`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Linux]`_`f, sowie der `F33f`_`[Entwicklungsumgebung`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=Integrierte_Entwicklungsumgebung]`_`f `F33f`_`[MonoDevelop`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=MonoDevelop]`_`f.
• `F33f`_`[SharpDevelop`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=SharpDevelop]`_`f – Open-Source-Entwicklungsumgebung für .NET-Sprachen.
>>Literatur
• Klaus Löffelmann: `*Visual Basic 2010 – Das Entwicklerbuch.`* 2010 Microsoft Press, ISBN 978-3-86645-535-1.
• Klaus Löffelmann: `*Visual Basic 2008 – Das Entwicklerbuch.`* 2008 Microsoft Press, ISBN 978-3-86645-506-1.
• Klaus Werner Wirtz: `*Visual Basic .NET 2010 praxisorientiert. Band 1: Programmieren für Windows`*. Norderstedt 2010, ISBN 978-3-8423-0014-9.
• Klaus Werner Wirtz: `*Visual Basic .NET 2010 praxisorientiert. Band 2: Datenbanken und Web-Anwendungen`*. Norderstedt 2010, ISBN 978-3-8423-0722-3.
• Peter Monadjemi: `*Visual Basic 2005 Kompendium`*. Markt-und-Technik, 2006
• Thomas Theis: `*Einstieg in Visual Basic 2012`*. Rheinwerk Verlag, 2012, ISBN 978-3-8362-1959-4.
• Thomas Theis: Einstieg in Visual Basic 2017. Rheinwerk Verlag 2017, ISBN 978-3-8362-5930-9.
• René Martin: `*Einstieg in VB.NET`*. Galileo Computing, 2003, ISBN 3-89842-277-1.
• Joachim Fuchs, Andreas Barchfeld: `*Das Visual Basic 2005 Codebook`*. Addison-Wesley in Pearson Education Deutschland, München 2006, ISBN 3-8273-2272-3.
>>Weblinks
Wikibooks: Visual Basic .NET
– Lern- und Lehrmaterialien
• MSDN Developer Center – Visual Basic
• Get the BASICs. VB.NET für Einsteiger und Umsteiger in zehn Teilen – MSDN Webcast
• Linkkatalog zum Thema Visual Basic bei `*curlie.org`* (ehemals `F33f`_`[DMOZ`:/page/entry.mu`zim=wikipedia_de_all_nopic_2026-01.zim|entry_path=DMOZ]`_`f)
• .NET-Technologien in Visual Basic 6.0
• Visual Basic 2008 Express
• OpenBook von Galileo-Computing
• www.dotnetframework.de
• Openbook: `*Einstieg in VB.NET`* von René Martin
• Openbook von Galileo-Computing: `*Einstieg in Visual Basic 2010`*
>>Einzelnachweise
`:cite-note-1`!1.`! dotnet.microsoft.com/…/9.0 (englisch) – dort genauer erstmals in der zweiten Wartungsausgabe (9.0.2), freigegeben am 11.2.2025 (2025-02-11, zusammen mit dem dort sobezeichneten „SDK 9.0.200“), u. a. mit „Visual Basic 17.13“
`:cite-note-2`!2.`! github.com/dotnet/core/releases/tag/v9.0.2 (englisch)
`:cite-note-3`!3.`! `F0af`_`[↑`#cite-ref-3]`_`f Produktseite Visual Basic Express Edition
`:cite-note-us20040230959-4`!4.`! `F0af`_`[↑`#cite-ref-us20040230959-4-0]`_`f Patentanmeldung US20040230959A1: `*Is Not Operator.`* Angemeldet am 14. Mai 2003, veröffentlicht am 18. November 2004, Anmelder: Microsoft Technology Licensing LLC, Erfinder: Paul A. Vick Jr. et al.
`:cite-note-5`!5.`! `F0af`_`[↑`#cite-ref-5]`_`f Überblick über die Änderungen in Visual Basic 9 (englisch)
`:cite-note-6`!6.`! `F0af`_`[↑`#cite-ref-6]`_`f Zukünftige Visual Studio-Versionen (englisch)
`:cite-note-7`!7.`! `F0af`_`[↑`#cite-ref-7]`_`f Architektur von .NET Framework 3.5 (deutsch)
`:cite-note-0-8`!8.`! `F0af`_`[↑`#cite-ref-0-8-0]`_`f `*TechNet Wiki.`* Abgerufen am 18. Mai 2022.
`:cite-note-9`!9.`! `F0af`_`[↑`#cite-ref-9]`_`f `*New Language Features in Visual Basic 14.`* 9. Dezember 2014, abgerufen am 18. Mai 2022 (amerikanisches Englisch).
`:cite-note-1-10`!10.`! `F0af`_`[↑`#cite-ref-1-10-0]`_`f KathleenDollard: `*What's new - Visual Basic.`* Abgerufen am 18. Mai 2022 (amerikanisches Englisch).
`c`F0af`_`[↑ Back to top`#top]`_`f`a